// /**
//   ******************************************************************************
//   * @file
//   * @brief
//   ******************************************************************************
//   * @note
//
//  */
//
// /* Includes ------------------------------------------------------------------*/
//
// #include "can.h"
// #include "usart.h"
// #include <string.h>
// #include <stdio.h>
// #include "CanCommand.h"
// /* Definitions ---------------------------------------------------------*/
//
// /* Private variables ---------------------------------------------------------*/
// uint8_t byte[4];
// static CAN_TxHeaderTypeDef  tx_message;
// uint8_t RxBuffer[LENGTH], RxBuf_UART6;
// MI_Motor motor1;
// /* Global variables ---------------------------------------------------------*/
//
// /*Functions------------------------------------------------------------------*/
// ////?????��?????
// uint16_t float_to_uint(float x, float x_min, float x_max, int bits){
// 	float span = x_max - x_min;
// 	float offset = x_min;
// 	if(x > x_max) x=x_max;
// 	else if(x < x_min) x= x_min;
// 	return (uint16_t) ((x-offset)*((float)((1<<bits)-1))/span);
// }
// /*******************************************************************************
// * @function     : ???????4??????
// * @param        : ??????
// * @return       : 4???????
// * @description  : IEEE 754 ��??
// *******************************************************************************/
// uint8_t* Float_to_Byte(float f)
// {
// 	unsigned long longdata = 0;
// 	longdata = *(unsigned long*)&f;
// 	byte[0] = (longdata & 0xFF000000) >> 24;
// 	byte[1] = (longdata & 0x00FF0000) >> 16;
// 	byte[2] = (longdata & 0x0000FF00) >> 8;
// 	byte[3] = (longdata & 0x000000FF);
// 	return byte;
// }
//
// /*******************************************************************************
// * @function     : ��????????16��?????????
// * @param        : 1. 16��???? 2.??????????? 3.??????????? 4. ????��??
// * @return       : ?????????????
// * @description  : None
// *******************************************************************************/
// float uint16_to_float(uint16_t x,float x_min,float x_max,int bits){
//     uint32_t span = (1 << bits) - 1;
//     float offset = x_max - x_min;
//     return offset * x / span + x_min;
// }
//
// /*******************************************************************************
// * @function     : ????????????
// * @param        : 1. ??????? 2.???CANID 3.?????? 4.???????????1.????? 2. ��???? 3. ????? 4. ????????
// * @return       : None
// * @description  : ??????????? CANID ?????? ??????????
// *******************************************************************************/
// void Init_Motor(MI_Motor *Motor,uint8_t Can_Id,int Motor_Num,float mode){
// 	Motor->CAN_ID=Can_Id;
// 	Motor->Motor_Nbr=Motor_Num;
// 	// HAL_Delay((10));
// 	Set_Mode(Motor,mode);
// 	// HAL_Delay(10);
// 	Enable_Motor(Motor);
// 	Set_ZeroPos(Motor);
// }
//
//
// /*******************************************************************************
// * @function     : ?????????????ID?��???CANID
// * @param        : ????????��????CANID
// * @return       : ???ID
// * @description  : ????ID??8-15��
// *******************************************************************************/
// uint32_t Get_Motor_ID(uint32_t CAN_ID_Frame){
// 	return (CAN_ID_Frame&0xFFFF)>>8;
// }
//
// /*******************************************************************************
// * @function     : ?????
// * @param        : ?????????????
// * @return       : None
// * @description  : ?????
// *******************************************************************************/
// void Enable_Motor(MI_Motor *Motor){
// 	uint32_t Send_ID;
// 	uint8_t temp[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
// 	Send_ID = Communication_Type_MotorEnable<<24|Master_CAN_ID<<8|Motor->CAN_ID;
// 	CAN_cmd_send(Send_ID, temp);
// }
//
// /*******************************************************************************
// * @function     : ?????
// * @param        : 1.????????????? 2.???????��??0 ????? 1?????
// * @return       : None
// * @description  : ?????
// *******************************************************************************/
// void Stop_Motor(MI_Motor *Motor,uint8_t clear_error){
// 	uint32_t Send_ID;
// 	uint8_t temp[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
// 	temp[0]=clear_error;
// 	Send_ID = Communication_Type_MotorStop<<24|Master_CAN_ID<<8|Motor->CAN_ID;
// 	CAN_cmd_send(Send_ID, temp);
// }
//
// /*******************************************************************************
// * @function     : ????????????????
// * @param        : 1.????????????? 2.????? 3.???ID?
// * @return       : None
// * @description  : ?????? ??? ??? ??? ???????
// *******************************************************************************/
// void Motor_Data_Handler(MI_Motor *Motor,uint8_t DataFrame[8],uint32_t IDFrame){
//
// 		Motor->Angle=uint16_to_float(DataFrame[0]<<8|DataFrame[1],MIN_P,MAX_P,16);
//
// 		Motor->Speed=uint16_to_float(DataFrame[2]<<8|DataFrame[3],MIN_S,MAX_S,16);
//
// 		Motor->Torque=uint16_to_float(DataFrame[4]<<8|DataFrame[5],MIN_T,MAX_T,16);
//
// 		Motor->Temp=(DataFrame[6]<<8|DataFrame[7])*Temp_Gain;
//
// 		Motor->error_code=(IDFrame&0x1F0000)>>16;
//
// }
//
// /*******************************************************************************
// * @function     : ��????????
// * @param        : 1.????????????? 2.��??????????? 3.��?????? 4.��?????????????
// * @return       : None
// * @description  : None
// *******************************************************************************/
// void Set_Motor_Parameter(MI_Motor *Motor,uint16_t Index,float Value,char Value_type){
// 	uint32_t Send_ID;
// 	uint8_t Send_Data[8];
// 	Send_ID = Communication_Type_SetSingleParameter<<24|Master_CAN_ID<<8|Motor->CAN_ID;
// 	Send_Data[0]=Index;
// 	Send_Data[1]=Index>>8;
// 	Send_Data[2]=0x00;
// 	Send_Data[3]=0x00;
// 	if(Value_type == 'f'){
// 		Float_to_Byte(Value);
// 		Send_Data[4]=byte[3];
// 		Send_Data[5]=byte[2];
// 		Send_Data[6]=byte[1];
// 		Send_Data[7]=byte[0];
// 	}
// 	else if(Value_type == 's'){
// 		Send_Data[4]=(uint8_t)Value;
// 		Send_Data[5]=0x00;
// 		Send_Data[6]=0x00;
// 		Send_Data[7]=0x00;
// 	}
// 	CAN_cmd_send(Send_ID, Send_Data);
// }
//
// /*******************************************************************************
// * @function     : ????????????
// * @param        : %2
// * @return       : %3
// * @description  : %4
// *******************************************************************************/
// void Set_Mode(MI_Motor *Motor,float Mode){
//
// 	Set_Motor_Parameter(Motor,Run_mode,Mode,'s');
// }
//
// /*******************************************************************************
// * @function     : ???????????????????
// * @param        : %2
// * @return       : %3
// * @description  : %4
// *******************************************************************************/
// void Set_Current(MI_Motor *Motor,float Current){
//
// 	Set_Motor_Parameter(Motor,Iq_Ref,Current,'f');
// }
//
// /*******************************************************************************
// * @function     : ????????��???
// * @param        : %2
// * @return       : %3
// * @description  : %4
// *******************************************************************************/
// void Set_ZeroPos(MI_Motor *Motor){
// 	uint32_t Send_ID;
// 	uint8_t Send_Data[8]={0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
// 	Send_ID = Communication_Type_SetPosZero<<24|Master_CAN_ID<<8|Motor->CAN_ID;
// 	CAN_cmd_send(Send_ID, Send_Data);
// }
//
// /*******************************************************************************
// * @function     : ??????CANID
// * @param        : %2
// * @return       : %3
// * @description  : %4
// *******************************************************************************/
// void Set_CANID(MI_Motor *Motor,uint8_t CAN_ID){
// 	uint32_t Send_ID;
// 	uint8_t Send_Data[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
// 	Send_ID = Communication_Type_CanID<<24|CAN_ID<<16|Master_CAN_ID<<8|Motor->CAN_ID;
// 	CAN_cmd_send(Send_ID, Send_Data);
// }
//
//
// /* Exported function declarations --------------------------------------------*/
//
// void motor_controlmode(MI_Motor *Motor, uint8_t Can_Id, float torque, float MechPosition, float speed, float kp, float kd)
// {
// 	Motor->CAN_ID = Can_Id;
// 	uint32_t Send_ID;
// 	uint8_t Send_Data[8];
// 	Send_ID = Communication_Type_MotionControl<<24|float_to_uint(torque,MIN_T,MAX_T,16)<<8|Motor->CAN_ID;
// 	Send_Data[0]=float_to_uint(MechPosition,MIN_P,MAX_P,16)>>8;
// 	Send_Data[1]=float_to_uint(MechPosition,MIN_P,MAX_P,16);
// 	Send_Data[2]=float_to_uint(speed,MAX_V,MIN_V,16)>>8;
// 	Send_Data[3]=float_to_uint(speed,MAX_V,MIN_V,16);
// 	Send_Data[4]=float_to_uint(kp,MAX_KP,MIN_KP,16)>>8;
// 	Send_Data[5]=float_to_uint(kp,MAX_KP,MIN_KP,16);
// 	Send_Data[6]=float_to_uint(kd,MAX_KD,MIN_KD,16)>>8;
// 	Send_Data[7]=float_to_uint(kd,MAX_KD,MIN_KD,16);
// 	CAN_cmd_send(Send_ID, Send_Data);
// }
//
// void CAN_cmd_send(uint32_t Send_ID, uint8_t *can_send_data)
// {
//     uint32_t send_mail_box;
// 	tx_message.ExtId = Send_ID;
//     tx_message.IDE = CAN_ID_EXT;
//     tx_message.RTR = CAN_RTR_DATA;
//     tx_message.DLC = 0x08;
//
//     if(HAL_CAN_AddTxMessage(&hcan1, &tx_message, can_send_data, &send_mail_box) == HAL_OK)
// 		{
// 			// char str[]="send";
// 			//HAL_UART_Transmit(&huart6, (uint8_t*)str, strlen(str), 0xFFFF);
// 		}
// }
//
// void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
// {
// 	CAN_RxHeaderTypeDef RxHead; /**!< can???��??? */
//   uint8_t data[8];
//
//   HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHead, data);
// 	// printf("x\n");
// 	// motor1.motorID=Get_Motor_ID(RxHead.ExtId);
// 	// motor1.motorAngle=uint16_to_float(data[0]<<8|data[1],MIN_P,MAX_P,16);
// 	// motor1.motorV=uint16_to_float(data[2]<<8|data[3],MIN_S,MAX_S,16);
// 	// motor1.motorTorque=uint16_to_float(data[4]<<8|data[5],MIN_T,MAX_T,16);
// 	// motor1.motorTemp=(data[6]<<8|data[7])*Temp_Gain;
//
//
// }
